package main

import (
	"fmt"
)

/*
类型和接口是多对多的关系，一个类型可以实现多个接口，一个接口可以被多个接口实现
*/

/*
多个接口一个实现类型
*/
// 定义接口
type interF1 interface {
	func1()
}

type interF2 interface {
	func1()
}

//定义接口的实现类，接收者

type strt1 struct {
	name string
	age  int
}

// 接口的实现

func (p *strt1) func1() {
	fmt.Println("strt1实现第一种接口")
}

func (q *strt1) func2() {
	fmt.Println("strt1实现第二种接口")
}

/*
一个接口多个实现类型
*/
type interF3 interface {
	func4()
	func5()
}

type strt2 struct {
	name string
}

type strt3 struct {
	age int
}

// 实现方法(两个类型都实现一个接口的函数) 注意是一个类型都实现所有的方法，该类型才能实例化该接口
func (p *strt2) func4() {
	fmt.Println("name是", p.name)
}

func (p *strt2) func5() {
	fmt.Println("name是", p.name)
}

func (p *strt3) func5() {
	fmt.Println("name是", p.age)
}

func (p *strt3) func4() {
	fmt.Println("name是", p.age)
}

/*
采用interface作为类型字段(通过一个定义一个接口，传入不到的类型，实现不同的功能)
*/
type Write interface {
	wr()
}

type writefile struct {
}

func (w *writefile) wr() {
	fmt.Println("写文件的实现")
}

type writedata struct {
}

func (w *writedata) wr() {
	fmt.Println("写数据的实现")
}

func main() {
	//实例化接口变量
	var in interF1 = new(strt1) //实例化一个接口变量并赋值对象
	in.func1()                  //strt1实现第一种接口

	// 实例化接口变量
	var in2 interF3 = &strt2{name: "jiang"}
	in2.func5()

	var int3 interF3 = &strt3{age: 18}
	int3.func4()

	// 接口变量
	var in3 Write = &writefile{}
	in3.wr() //写文件的实现
	var in4 Write = &writedata{}
	in4.wr() //写数据的实现

}
